#include "bridge_entry.h"
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>

/**
 * 解析device mode
 */
char *parse_device_mode(char *res){
    if(strcmp(res, "1") == 0) {
        return "bridge";
    }
    if(strcmp(res, "2") == 0) {
        return "router";
    }
    if(strcmp(res, "3") == 0) {
        return "soho";
    }
    return "unknown";
}
/**
 * 解析无线模式
 */
char *parse_wireless_mode(char *res){
    if(strcmp(res, "1") == 0) {
        return "sta";
    }
    if(strcmp(res, "2") == 0) {
        return "ap";
    }
    if(strcmp(res, "3") == 0) {
        return "aprepeater";
    }
    if(strcmp(res, "4") == 0) {
        return "apwds";
    }
    return "unknown";
}
/**
 * 取字符串中的数字
 */
int extract_number(const char *str) {
    // 1. 查找冒号位置
    const char *colon = strchr(str, ':');
    if (!colon) {
        fprintf(stderr, "错误：字符串格式无效\n");
        return -1;
    }
    
    // 2. 定位引号内的数字部分
    const char *quote_start = strchr(colon + 1, '"');
    if (!quote_start) {
        fprintf(stderr, "错误：缺少起始引号\n");
        return -1;
    }
    
    const char *quote_end = strchr(quote_start + 1, '"');
    if (!quote_end) {
        fprintf(stderr, "错误：缺少结束引号\n");
        return -1;
    }
    
    // 3. 提取引号内的数字字符串
    size_t num_len = quote_end - quote_start - 1;
    char num_str[20];
    if (num_len >= sizeof(num_str)) {
        fprintf(stderr, "错误：数字长度超出缓冲区\n");
        return -1;
    }
    
    strncpy(num_str, quote_start + 1, num_len);
    num_str[num_len] = '\0';  // 确保字符串终止
    
    // 4. 转换为整数
    char *endptr;
    long result = strtol(num_str, &endptr, 10);
    
    // 5. 验证转换结果
    if (endptr == num_str || *endptr != '\0') {
        fprintf(stderr, "错误：'%s' 不是有效数字\n", num_str);
        return -1;
    }
    
    return (int)result;
}
/**
 * 取字符串中的时间
 */
char* extract_time_string(const char *str) {
    // 1. 查找冒号位置
    const char *colon = strchr(str, ':');
    if (!colon) {
        fprintf(stderr, "错误：字符串格式无效\n");
        return NULL;
    }
    
    // 2. 定位引号内的内容
    const char *quote_start = strchr(colon + 1, '"');
    if (!quote_start) {
        fprintf(stderr, "错误：缺少起始引号\n");
        return NULL;
    }
    
    const char *quote_end = strchr(quote_start + 1, '"');
    if (!quote_end) {
        fprintf(stderr, "错误：缺少结束引号\n");
        return NULL;
    }
    
    // 3. 计算时间字符串长度
    size_t time_len = quote_end - quote_start - 1;
    if (time_len <= 0) {
        fprintf(stderr, "错误：时间字符串为空\n");
        return NULL;
    }
    
    // 4. 分配内存并复制时间字符串
    char *time_str = malloc(time_len + 1);
    if (!time_str) {
        perror("内存分配失败");
        return NULL;
    }
    
    strncpy(time_str, quote_start + 1, time_len);
    time_str[time_len] = '\0';  // 添加终止符
    
    return time_str;
}

/**
 * 取字符串中的Mac地址
 */
char* format_mac_address(const char* input) {
    // 1. 查找前缀位置
    const char* prefix = "Hex-STRING: ";
    const char* start = strstr(input, prefix);
    if (!start) {
        fprintf(stderr, "错误：未找到Hex-STRING前缀\n");
        return NULL;
    }
    
    // 2. 定位MAC地址起始位置
    start += strlen(prefix);
    
    // 3. 计算MAC地址长度
    const char* end = start;
    int count = 0;
    while (*end && count < 12) { // MAC地址由12个十六进制字符组成
        if (isxdigit(*end)) {
            count++;
        }
        end++;
    }
    
    // 4. 验证MAC地址长度
    if (count != 12) {
        fprintf(stderr, "错误：无效的MAC地址长度\n");
        return NULL;
    }
    
    // 5. 分配内存并格式化MAC地址
    char* mac = malloc(18); // 12字符 + 5冒号 + 1结束符 = 18字节
    if (!mac) {
        perror("内存分配失败");
        return NULL;
    }
    
    int index = 0;
    for (int i = 0; i < 12; i++) {
        mac[index++] = toupper(start[i]); // 转换为大写
        if ((i + 1) % 2 == 0 && i < 11) { // 每2个字符后加冒号（最后不加）
            mac[index++] = ':';
        }
    }
    mac[index] = '\0'; // 结束字符串
    
    return mac;
}

char* extract_quoted_content(const char* input) {
    char buffer[20]; // 临时缓冲区
    if (sscanf(input, "STRING: \"%20[^\"]\"", buffer) == 1) {
        char* result = strdup(buffer); // 复制到堆内存
        return result;
    }
    return NULL;
}

// 提取IP地址的函数
char* extract_ip_address(const char* input) {
    // 查找"IpAddress:"前缀
    const char* prefix = "IpAddress: ";
    const char* ip_start = strstr(input, prefix);
    
    if (!ip_start) {
        return NULL; // 未找到前缀
    }
    
    // 移动到IP地址开始位置
    ip_start += strlen(prefix);
    
    // 计算IP地址长度
    const char* ip_end = ip_start;
    while (*ip_end && !isspace(*ip_end)) {
        ip_end++;
    }
    size_t ip_len = ip_end - ip_start;
    
    // 分配内存并复制IP地址
    char* ip = malloc(ip_len + 1);
    if (!ip) {
        return NULL; // 内存分配失败
    }
    
    strncpy(ip, ip_start, ip_len);
    ip[ip_len] = '\0'; // 添加终止符
    
    return ip;
}
/******************提交OID中远端设备的Mac地址***********************/
// 检查字符串是否全为数字
int is_all_digits(const char *str) {
    for (int i = 0; str[i]; i++) {
        if (!isdigit((unsigned char)str[i])) {
            return 0;
        }
    }
    return 1;
}

/**
 * 从OID字符串中提取数字序列部分
 * @param input 输入字符串
 * @param output 输出缓冲区
 * @param max_len 输出缓冲区最大长度
 * @return 成功返回0，失败返回-1
 */
int extract_digit_sequence(const char *input, char *output, size_t max_len) {
    // 查找最后一个点
    const char *last_dot = strrchr(input, '.');
    if (!last_dot) {
        fprintf(stderr, "错误：未找到有效的数字序列\n");
        return -1;
    }
    
    // 向前查找5个点（对应6个数字段）
    const char *start = last_dot;
    int dot_count = 0;
    
    while (start > input && dot_count < 5) {
        start--;
        if (*start == '.') {
            dot_count++;
        }
    }
    
    // 验证是否找到足够的点
    if (dot_count < 5) {
        fprintf(stderr, "错误：需要6个数字值，找到 %d 个\n", dot_count + 1);
        return -1;
    }
    
    // 定位序列起始位置（当前start指向第一个点的位置）
    start++; // 移动到第一个数字
    
    // 计算序列长度（从start到字符串结尾）
    size_t seq_len = strlen(start);
    if (seq_len >= max_len) {
        fprintf(stderr, "错误：输出缓冲区过小\n");
        return -1;
    }
    
    // 复制数字序列（包含最后一个数字段）
    strncpy(output, start, seq_len);
    output[seq_len] = '\0';
    return 0;
}

/**
 * 将数字序列转换为十六进制格式
 * @param sequence 输入的数字序列
 * @param hex_output 输出缓冲区
 * @param max_len 输出缓冲区最大长度
 * @return 成功返回0，失败返回-1
 */
int convert_to_hex_format(const char *sequence, char *hex_output, size_t max_len) {
    char *token;
    char *saveptr;
    char temp[256];
    char *output_ptr = hex_output;
    
    // 复制序列到临时缓冲区
    strncpy(temp, sequence, sizeof(temp) - 1);
    temp[sizeof(temp) - 1] = '\0';
    
    // 检查缓冲区大小
    if (max_len < 18) {
        fprintf(stderr, "错误：输出缓冲区过小\n");
        return -1;
    }
    
    // 分割数字序列
    token = strtok_r(temp, ".", &saveptr);
    int count = 0;
    
    while (token) {
        // 验证是否为纯数字
        if (!is_all_digits(token)) {
            fprintf(stderr, "错误：无效数字 '%s'\n", token);
            return -1;
        }
        
        // 转换为整数
        char *endptr;
        long num = strtol(token, &endptr, 10);
        
        if (*endptr != '\0' || errno == ERANGE) {
            fprintf(stderr, "错误：无效数字 '%s'\n", token);
            return -1;
        }
        
        if (num < 0 || num > 255) {
            fprintf(stderr, "错误：值 %ld 超出范围 (0-255)\n", num);
            return -1;
        }
        
        // 格式化为十六进制
        if (count > 0) {
            *output_ptr++ = ':';
        }
        
        sprintf(output_ptr, "%02lX", num);
        output_ptr += 2;
        count++;
        
        token = strtok_r(NULL, ".", &saveptr);
    }
    
    // 验证数字段数量
    if (count != 6) {
        fprintf(stderr, "错误：需要6个数字值，找到 %d 个\n", count);
        return -1;
    }
    
    *output_ptr = '\0';
    return 0;
}
